/**
 * 小程序异步聊天接口对接示例
 * 简化版实现，快速集成AI客服功能
 * 
 * 使用方法：
 * 1. 复制此文件到小程序项目的utils目录
 * 2. 修改baseUrl为实际的API地址
 * 3. 在页面中引入并使用
 * 
 * @author AI客服系统
 * @version 1.0.0
 */

class MiniProgramChatAPI {
  constructor(config = {}) {
    // 配置参数
    this.baseUrl = config.baseUrl || 'http://localhost:8080/api/chat/async';
    this.pollingInterval = config.pollingInterval || 1000; // 轮询间隔(ms)
    this.maxPollingTime = config.maxPollingTime || 30000; // 最大轮询时间(ms)
    this.retryTimes = config.retryTimes || 3; // 重试次数
    
    // 内部状态
    this.currentTaskId = null;
    this.isPolling = false;
  }

  /**
   * 发送聊天消息（主要接口）
   * @param {Object} options 配置选项
   * @param {string} options.message 消息内容
   * @param {string} options.sessionId 会话ID（可选）
   * @param {function} options.onProgress 进度回调（可选）
   * @param {function} options.onSuccess 成功回调（可选）
   * @param {function} options.onError 错误回调（可选）
   * @returns {Promise<Object>} 聊天结果
   */
  async sendMessage(options) {
    const {
      message,
      sessionId = null,
      onProgress = null,
      onSuccess = null,
      onError = null
    } = options;

    try {
      // 参数验证
      if (!message || !message.trim()) {
        throw new Error('消息内容不能为空');
      }

      if (message.length > 2000) {
        throw new Error('消息内容过长，请控制在2000字符以内');
      }

      // 1. 提交异步任务
      const taskResponse = await this._submitTask(message, sessionId);
      this.currentTaskId = taskResponse.taskId;

      console.log('[ChatAPI] 任务已提交:', this.currentTaskId);

      // 2. 轮询获取结果
      const result = await this._pollTaskResult(this.currentTaskId, onProgress);
      
      // 3. 成功回调
      if (onSuccess) {
        onSuccess(result);
      }

      return result;

    } catch (error) {
      console.error('[ChatAPI] 发送消息失败:', error);
      
      // 错误回调
      if (onError) {
        onError(error);
      }
      
      throw error;
    } finally {
      this.currentTaskId = null;
      this.isPolling = false;
    }
  }

  /**
   * 取消当前任务
   */
  async cancelCurrentTask() {
    if (this.currentTaskId && this.isPolling) {
      try {
        await this._cancelTask(this.currentTaskId);
        this.isPolling = false;
        console.log('[ChatAPI] 任务已取消:', this.currentTaskId);
      } catch (error) {
        console.error('[ChatAPI] 取消任务失败:', error);
      }
    }
  }

  /**
   * 获取系统状态
   */
  async getSystemStatus() {
    try {
      const response = await this._request({
        url: `${this.baseUrl}/system/status`,
        method: 'GET'
      });
      return response.data;
    } catch (error) {
      console.error('[ChatAPI] 获取系统状态失败:', error);
      throw error;
    }
  }

  // ==================== 私有方法 ====================

  /**
   * 提交异步任务
   */
  async _submitTask(message, sessionId) {
    const requestData = { message };
    if (sessionId) {
      requestData.sessionId = sessionId;
    }

    const response = await this._request({
      url: this.baseUrl,
      method: 'POST',
      data: requestData
    });

    if (response.data.status !== 'submitted') {
      throw new Error(response.data.message || '提交任务失败');
    }

    return response.data;
  }

  /**
   * 轮询任务结果
   */
  async _pollTaskResult(taskId, onProgress) {
    this.isPolling = true;
    const startTime = Date.now();
    let lastProgress = 0;

    while (this.isPolling && (Date.now() - startTime) < this.maxPollingTime) {
      try {
        // 查询任务状态
        const statusResponse = await this._request({
          url: `${this.baseUrl}/${taskId}/status`,
          method: 'GET'
        });

        const status = statusResponse.data;
        
        // 进度回调（避免重复调用）
        if (onProgress && status.progress !== lastProgress) {
          onProgress({
            progress: status.progress,
            message: status.message,
            status: status.status,
            taskId: taskId
          });
          lastProgress = status.progress;
        }

        // 检查是否完成
        if (status.completed) {
          if (status.hasResult) {
            // 获取结果
            return await this._getTaskResult(taskId);
          } else {
            throw new Error(status.message || '任务处理失败');
          }
        }

        // 等待后继续轮询
        await this._sleep(this.pollingInterval);

      } catch (error) {
        // 网络错误重试
        if (this._isNetworkError(error)) {
          console.warn('[ChatAPI] 网络错误，等待重试...');
          await this._sleep(this.pollingInterval * 2);
          continue;
        }
        throw error;
      }
    }

    throw new Error('任务处理超时，请重试');
  }

  /**
   * 获取任务结果
   */
  async _getTaskResult(taskId) {
    const response = await this._request({
      url: `${this.baseUrl}/${taskId}/result`,
      method: 'GET'
    });

    const result = response.data;
    if (result.status !== 'success') {
      throw new Error(result.errorMessage || '获取结果失败');
    }

    return {
      reply: result.reply,
      sessionId: result.sessionId,
      completeTime: result.completeTime,
      taskId: taskId
    };
  }

  /**
   * 取消任务
   */
  async _cancelTask(taskId) {
    await this._request({
      url: `${this.baseUrl}/${taskId}`,
      method: 'DELETE'
    });
  }

  /**
   * 统一请求方法
   */
  async _request(options, retryCount = 0) {
    try {
      const response = await new Promise((resolve, reject) => {
        wx.request({
          ...options,
          header: {
            'Content-Type': 'application/json',
            ...options.header
          },
          success: resolve,
          fail: reject
        });
      });

      // 检查HTTP状态码
      if (response.statusCode >= 400) {
        throw new Error(`HTTP ${response.statusCode}: ${response.data?.message || '请求失败'}`);
      }

      return response;

    } catch (error) {
      // 重试逻辑
      if (retryCount < this.retryTimes && this._isNetworkError(error)) {
        console.warn(`[ChatAPI] 请求失败，第${retryCount + 1}次重试...`);
        await this._sleep(1000 * (retryCount + 1)); // 递增延时
        return this._request(options, retryCount + 1);
      }
      throw error;
    }
  }

  /**
   * 判断是否为网络错误
   */
  _isNetworkError(error) {
    return error.errMsg && (
      error.errMsg.includes('timeout') ||
      error.errMsg.includes('fail') ||
      error.errMsg.includes('network')
    );
  }

  /**
   * 延时函数
   */
  _sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// ==================== 使用示例 ====================

/**
 * 页面使用示例
 */
const pageExample = {
  data: {
    messages: [],
    inputValue: '',
    loading: false,
    loadingText: '',
    progress: 0,
    sessionId: ''
  },

  onLoad() {
    // 初始化聊天API
    this.chatAPI = new MiniProgramChatAPI({
      baseUrl: 'http://localhost:8080/api/chat/async', // 修改为实际地址
      pollingInterval: 1000,
      maxPollingTime: 30000
    });
  },

  // 发送消息
  async sendMessage() {
    const message = this.data.inputValue.trim();
    if (!message) {
      wx.showToast({ title: '请输入消息', icon: 'none' });
      return;
    }

    // 添加用户消息
    this.addMessage({
      type: 'user',
      content: message,
      time: this.formatTime(new Date())
    });

    // 清空输入框并显示加载状态
    this.setData({
      inputValue: '',
      loading: true,
      progress: 0,
      loadingText: '正在发送...'
    });

    try {
      // 发送消息
      const result = await this.chatAPI.sendMessage({
        message: message,
        sessionId: this.data.sessionId,
        onProgress: (progress) => {
          this.setData({
            progress: progress.progress,
            loadingText: progress.message
          });
        }
      });

      // 添加AI回复
      this.addMessage({
        type: 'ai',
        content: result.reply,
        time: this.formatTime(new Date())
      });

      // 保存会话ID
      if (result.sessionId) {
        this.setData({ sessionId: result.sessionId });
      }

    } catch (error) {
      console.error('发送消息失败:', error);
      wx.showToast({
        title: error.message || '发送失败，请重试',
        icon: 'none',
        duration: 3000
      });
    } finally {
      this.setData({
        loading: false,
        progress: 0,
        loadingText: ''
      });
    }
  },

  // 添加消息到列表
  addMessage(message) {
    const messages = [...this.data.messages, message];
    this.setData({ messages });
    
    // 滚动到底部
    this.setData({
      scrollTop: messages.length * 100
    });
  },

  // 输入框变化
  onInputChange(e) {
    this.setData({ inputValue: e.detail.value });
  },

  // 取消发送
  cancelSend() {
    this.chatAPI.cancelCurrentTask();
    this.setData({
      loading: false,
      progress: 0,
      loadingText: ''
    });
  },

  // 格式化时间
  formatTime(date) {
    const hours = date.getHours().toString().padStart(2, '0');
    const minutes = date.getMinutes().toString().padStart(2, '0');
    return `${hours}:${minutes}`;
  },

  // 页面隐藏时取消任务
  onHide() {
    if (this.chatAPI) {
      this.chatAPI.cancelCurrentTask();
    }
  }
};

// 导出
module.exports = {
  MiniProgramChatAPI,
  pageExample
};

// ==================== 快速集成指南 ====================

/**
 * 1. 在app.js中全局初始化（推荐）
 * 
 * App({
 *   onLaunch() {
 *     // 全局初始化聊天API
 *     this.globalData.chatAPI = new MiniProgramChatAPI({
 *       baseUrl: 'https://your-domain.com/api/chat/async'
 *     });
 *   },
 *   globalData: {
 *     chatAPI: null
 *   }
 * });
 * 
 * 2. 在页面中使用
 * 
 * const app = getApp();
 * 
 * Page({
 *   async sendMessage() {
 *     try {
 *       const result = await app.globalData.chatAPI.sendMessage({
 *         message: '你好',
 *         onProgress: (progress) => {
 *           console.log('进度:', progress.progress + '%');
 *         }
 *       });
 *       console.log('AI回复:', result.reply);
 *     } catch (error) {
 *       console.error('发送失败:', error.message);
 *     }
 *   }
 * });
 * 
 * 3. 错误处理最佳实践
 * 
 * - 网络异常：自动重试3次
 * - 超时处理：30秒后自动取消
 * - 用户取消：调用cancelCurrentTask()
 * - 参数验证：消息长度、格式检查
 * 
 * 4. 性能优化建议
 * 
 * - 合理设置轮询间隔（1-2秒）
 * - 页面隐藏时取消任务
 * - 缓存会话ID保持对话连续性
 * - 显示进度条提升用户体验
 */